- Add a changes.txt
- raise an exception in an unimplemented method



Ok, now the program can parse all Delphi units of the VCL
source folder.
We have started generating the stuff.
We can create standard Delphi components, read/write properties of basic types,
enumerations, sets, objects, chars.
We can use the Components events and even the var arguments of Delphi are supported.
It's needed for the OnClose event of a TForm for instance.
There are 2 records defined for TPoint and TRect.
We can call object methods and receive a result if it's a function.
We support indexed properties as methods : Index[1] <=> Index(1)

We must support the indexed properties for write access (generate a SetXXX(..., value) )
We must support var arg in method calls.
The events work only with our subclassed classes. It means that it won't work
with an object created by another object, like a TFont in a TMemo. We should
create classes that contain only the events of another class. But there's the
problem of cleaning this instances.
We must support global functions/procedures


Ideas:
------
  * Generate one python class for each delphi class
  * Generate one delphi class attached to each delphi vcl class
    This class will contain a ref to the Delphi object and to
    the python object, and will handle all events of the delphi class
    by declaring the events and assigning them to the delphi object.
  * Generate python functions for the methods of the Delphi objects.
  * Build a python type for handling the var args of Delphi (python
    does not support this directly: we must have an object containing
    a python object that is the real arg, and then the delphi part will
    be able to change the content of an arg).
  * Use the Tag property to store the attached delphi classes
  * When reading an object property, examine its tag field:
      - if it contains an attached delphi class, then return
        the python object associated with
      - else create a python object maping the vcl object
  * case of delphi sets, intervals, indexed properties

  * override default memory allocator and allocates always 4 bytes more.
    It will let us use this area to store a pointer to the Python object
    associated with the Delphi object and retrieve it instantly.
    That way we'll be able to attach empty classes with object events.

Problems:
---------
I had to set the AutoFinalize to False, because it generated a memory
access exception. It seems to be bound to the creation of our
global components (Application and Screen in Forms.py).

I had to avoid owning the components generated for the VCL, because
when the program quits it generates a memory access exception, even
if we don't even execute a Python script !

But I set the AutoFinalize again to True and now I don't get any
exception. So, it seems that there's a problem with the freeing
of the TPythonClients. It's not a big problem since they are global
objects and they will automatically be freed when the process exits.

